home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / common / timeoutsocket.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  9KB  |  272 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from util.primitives import lock
  5. import common
  6. from logging import getLogger
  7. from util import Timer
  8. log = getLogger('common.timeoutsocket')
  9. info = log.info
  10.  
  11. class TimeoutSocket(common.socket):
  12.     
  13.     def tryconnect(self, ips, on_connect, on_fail, timeout = 2):
  14.         self.cancel_timeout()
  15.         self.timetowait = timeout
  16.         self.on_connect = on_connect
  17.         self.on_fail = on_fail
  18.         self._ips = iptuples(ips)
  19.         self.attempts = 0
  20.         self._accepting = False
  21.         self.try_connect()
  22.  
  23.     
  24.     def try_connect(self):
  25.         addr = self._ips[self.attempts]
  26.         log.warning('tryconnect: %r', (addr,))
  27.         self.attempts += 1
  28.         self.timeout = Timer(self.timetowait, (lambda s = (self.socket,): self.handle_timeout(s)))
  29.         self.make_socket()
  30.         if self.timeout is not None:
  31.             self.timeout.start()
  32.         
  33.         
  34.         def succ(*a, **k):
  35.             print 'WIN'
  36.  
  37.         
  38.         def fail(*a, **k):
  39.             print 'FAIL'
  40.  
  41.         self.connect(addr, success = succ, error = fail)
  42.  
  43.     
  44.     def tryaccept(self, addr, on_connect, on_fail, timeout = 1.5):
  45.         self._accepting = True
  46.         info('tryaccept Y=%r, N=%r', on_connect, on_fail)
  47.         self.on_connect = on_connect
  48.         self.on_fail = on_fail
  49.         info('listening for a connection at %r', (addr,))
  50.         self.make_socket()
  51.         common.socket.bind(self, addr)
  52.         self.listen(1)
  53.         if timeout:
  54.             info('timeout in %r secs', timeout)
  55.             self.timeout = Timer(timeout, (lambda s = (self.socket,): self.handle_timeout(s)))
  56.             self.timeout.start()
  57.         
  58.  
  59.     
  60.     def handle_timeout(self, socket):
  61.         info('TIMEOUT')
  62.         if socket is self.socket:
  63.             self.do_disconnect()
  64.         else:
  65.             socket.close()
  66.  
  67.     
  68.     def handle_expt(self):
  69.         info('handle_expt in %r', self)
  70.         self.do_disconnect()
  71.  
  72.     
  73.     def handle_error(self, e = None):
  74.         info('handle_error in %r', self)
  75.         import traceback as traceback
  76.         traceback.print_exc()
  77.         self.do_disconnect()
  78.  
  79.     
  80.     def do_disconnect(self):
  81.         log.warning('do_disconnect')
  82.         self.cancel_timeout()
  83.         self.close()
  84.         if not (self._accepting) and self.attempts < len(self._ips):
  85.             self.try_connect()
  86.         else:
  87.             self.on_fail()
  88.  
  89.     
  90.     def handle_connect(self):
  91.         info('connected!')
  92.         self.cancel_timeout()
  93.         self.on_connect(self)
  94.  
  95.     
  96.     def handle_accept(self):
  97.         self.cancel_timeout()
  98.         (conn, address) = self.accept()
  99.         info('%r connection accepted (%r), canceling timeout and calling %r', self, address, self.on_connect)
  100.         self.on_connect(conn)
  101.  
  102.     
  103.     def cancel_timeout(self):
  104.         if hasattr(self, 'timeout') and self.timeout is not None:
  105.             info('cancelling timeout')
  106.             self.timeout.cancel()
  107.         else:
  108.             log.warning('there was no timeout to cancel')
  109.         self.timeout = None
  110.  
  111.     
  112.     def __repr__(self):
  113.         if hasattr(self, 'ips') and len(self.ips):
  114.             return '<TimeoutSocket %s:%d>' % self.ips[0]
  115.         else:
  116.             pn = None
  117.             
  118.             try:
  119.                 pn = self.socket.getpeername()
  120.             finally:
  121.                 return '<%s connected to %r>' % (self.__class__.__name__, pn)
  122.  
  123.  
  124.  
  125.  
  126. class TimeoutSocketOne(common.socket):
  127.     
  128.     def try_connect(self, address, succ, fail, time_to_wait, provide_init):
  129.         provide_init(self)
  130.         self.real_success = succ
  131.         self.fail = fail
  132.         self.dead = False
  133.         self.data = None
  134.         self.make_socket()
  135.         self.timeoutvalid = True
  136.         self.timeout = Timer(time_to_wait, self.handle_timeout)
  137.         self.timeout.start()
  138.         print '*' * 40
  139.         funcinfo = funcinfo
  140.         import util
  141.         print funcinfo(self.connect)
  142.         print '*' * 40
  143.         self.connect(address, error = self.do_fail)
  144.  
  145.     try_connect = lock(try_connect)
  146.     
  147.     def succ(self):
  148.         info('succ')
  149.         self.real_success()
  150.  
  151.     
  152.     def do_fail(self, *a, **k):
  153.         info('do_fail')
  154.         if self.timeout is not None:
  155.             self.timeout.cancel()
  156.             self.timeout = None
  157.         
  158.         self.timeoutvalid = False
  159.         self.close()
  160.         print a, k
  161.         self.fail(*a, **k)
  162.  
  163.     do_fail = lock(do_fail)
  164.     
  165.     def handle_connect(self):
  166.         info('CONNECT')
  167.         if self.timeout is not None:
  168.             self.timeout.cancel()
  169.             self.timeout = None
  170.         
  171.         self.timeoutvalid = False
  172.         self.succ()
  173.  
  174.     handle_connect = lock(handle_connect)
  175.     
  176.     def handle_timeout(self):
  177.         info('TIMEOUT')
  178.         if self.timeoutvalid:
  179.             if self.timeout is not None:
  180.                 self.timeout.cancel()
  181.                 self.timeout = None
  182.             
  183.             self.timeoutvalid = False
  184.             self.close()
  185.             self.dead = True
  186.             self.fail()
  187.         
  188.  
  189.     handle_timeout = lock(handle_timeout)
  190.     
  191.     def collect_incoming_data(self, data):
  192.         self.data += data
  193.  
  194.     collect_incoming_data = lock(collect_incoming_data)
  195.     
  196.     def __error(self):
  197.         olddead = self.dead
  198.         self.dead = True
  199.         if self.timeout is not None:
  200.             self.timeout.cancel()
  201.             self.timeout = None
  202.         
  203.         self.timeoutvalid = False
  204.         self.close()
  205.         if not olddead:
  206.             self.fail()
  207.         
  208.  
  209.     __error = lock(__error)
  210.     
  211.     def handle_error(self, e = None):
  212.         info('ERROR: %r', e)
  213.         import traceback
  214.         traceback.print_exc()
  215.         self._TimeoutSocketOne__error()
  216.  
  217.     
  218.     def handle_expt(self):
  219.         info('EXPT')
  220.         self._TimeoutSocketOne__error()
  221.  
  222.     
  223.     def handle_close(self):
  224.         info('CLOSE')
  225.         self._TimeoutSocketOne__error()
  226.  
  227.  
  228.  
  229. class TimeoutSocketMulti(object):
  230.     
  231.     def tryconnect(self, ips, on_connect, on_fail, timeout = 2, cls = TimeoutSocketOne, provide_init = (lambda self: pass)):
  232.         self.provide_init = provide_init
  233.         self.cls = cls
  234.         self.timetowait = timeout
  235.         self.on_connect = on_connect
  236.         self.on_fail = on_fail
  237.         self._ips = iptuples(ips)
  238.         self.attempts = 0
  239.         self.try_connect()
  240.  
  241.     
  242.     def try_connect(self):
  243.         self.socket = self.cls(False)
  244.         address = self._ips[self.attempts]
  245.         log.warning('tryconnect: %r', address)
  246.         self.attempts += 1
  247.         self.socket.try_connect(address, self.win, self.lose, self.timetowait, self.provide_init)
  248.  
  249.     
  250.     def win(self):
  251.         self.on_connect(self.socket)
  252.  
  253.     
  254.     def lose(self, *a, **k):
  255.         if self.attempts < len(self._ips):
  256.             self.try_connect()
  257.         else:
  258.             self.on_fail(*a, **k)
  259.  
  260.  
  261.  
  262. def iptuples(ips):
  263.     if not hasattr(ips, '__len__'):
  264.         raise TypeError('ips must be (host, port) or [(host,port), (host,port)]')
  265.     
  266.     if isinstance(ips[0], basestring):
  267.         ips = tuple([
  268.             ips])
  269.     
  270.     return ips
  271.  
  272.